home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1992 June: ROMin Holiday / ADC Developer CD (1992-06) (''ROMin Holiday'')_iso / Developer Connection - 06-1992.iso / Developer Essentials / MPW Interfaces & Libraries / RIncludes / Pict.r < prev    next >
Encoding:
Text File  |  1992-01-29  |  47.8 KB  |  1,521 lines  |  [TEXT/MPS ]
  1. /*
  2.     Pict.r -- Type Declaration for Rez and DeRez
  3.     
  4.     Copyright Apple Computer, Inc. 1986-1991
  5.     All rights reserved.
  6.  
  7.     This PICT resource definition should probably used
  8.     for DeRez’ing purposes only.
  9.     
  10. */
  11.  
  12. #ifndef __PICT.R__
  13. #define __PICT.R__
  14.  
  15. type 'PICT' {
  16.     startOfPict:
  17.         unsigned integer = (endOfPict - startOfPict) >> 3;
  18.         Rect;                                    /* Bounds of picture */
  19.         switch {
  20.             case VersionOne:
  21.                 key integer = $1101;
  22.                 array OpCodes {
  23.                     switch {
  24.                         case NOP:
  25.                             key byte = $00;
  26.  
  27.                         case clipRgn:
  28.                             key byte = $01;
  29.     clipRgnStart:            integer = (clipRgnEnd[$$ArrayIndex(OpCodes)] - clipRgnStart[$$ArrayIndex(OpCodes)]) >> 3;
  30.                             Rect;                /* region's enclosing rect */
  31.                             hex string [$$Word(clipRgnStart[$$ArrayIndex(OpCodes)]) - 10];
  32.     clipRgnEnd:
  33.                         case bkPat:
  34.                             key byte = $02;
  35.                             hex string [8];
  36.                         
  37.                         case txFont:
  38.                             key byte = $03;
  39.                             integer;            /* font */
  40.                         
  41.                         case txFace:
  42.                             key byte = $04;
  43.                             unsigned hex byte;    /* text face */
  44.                         
  45.                         case txMode:
  46.                             key byte = $05;
  47.                             integer        srcCopy, srcOr, srcXor, srcBic,    /* mode */
  48.                                         notSrcCopy, notSrcOr, notSrcXor,
  49.                                         notSrcBic, patCopy, patOr, patXor,
  50.                                         patBic, notPatCopy, notPatOr, notPatBic;
  51.                         
  52.                         case spExtra:
  53.                             key byte = $06;
  54.                             unsigned hex longint;
  55.                         
  56.                         case pnSize:
  57.                             key byte = $07;
  58.                             Point;
  59.                         
  60.                         case pnMode:
  61.                             key byte = $08;
  62.                             unsigned hex integer;
  63.                         
  64.                         case pnPat:
  65.                             key byte = $09;
  66.                             hex string [8];
  67.                         
  68.                         case thePat:
  69.                             key byte = $0A;
  70.                             hex string [8];
  71.                         
  72.                         case ovSize:
  73.                             key byte = $0B;
  74.                             Point;
  75.                         
  76.                         case origin:
  77.                             key byte = $0C;
  78.                             integer;            /* dh */
  79.                             integer;            /* dv */
  80.                         
  81.                         case txSize:
  82.                             key byte = $0D;
  83.                             integer;
  84.                         
  85.                         case fgColor:
  86.                             key byte = $0E;
  87.                             longint;
  88.                         
  89.                         case bkColor:
  90.                             key byte = $0F;
  91.                             longint;
  92.                         
  93.                         case txRatio:
  94.                             key byte = $10;
  95.                             Point;                /* numer */
  96.                             Point;                /* denom */
  97.                         
  98.                         case picVersion:
  99.                             key byte = $11;
  100.                             byte;
  101.                         
  102.                         case line:
  103.                             key byte = $20;
  104.                             Point;                /* pnLoc */
  105.                             Point;                /* newPt */
  106.                         
  107.                         case lineFrom:
  108.                             key byte = $21;
  109.                             Point;                /* newPt */
  110.                         
  111.                         case shortLine:
  112.                             key byte = $22;
  113.                             Point;                /* pnLoc */
  114.                             byte;                /* dh */
  115.                             byte;                /* dv */
  116.                         
  117.                         case shortLineFrom:
  118.                             key byte = $23;
  119.                             byte;                /* dh */
  120.                             byte;                /* dv */
  121.                         
  122.                         case longText:
  123.                             key byte = $28;
  124.                             Point;                /* txLoc */
  125.                             pstring;
  126.                         
  127.                         case dhText:
  128.                             key byte = $29;
  129.                             byte;                /* dh */
  130.                             pstring;
  131.                             
  132.                         case dvText:
  133.                             key byte = $2A;
  134.                             byte;                /* dvh */
  135.                             pstring;
  136.                             
  137.                         case dhdvText:
  138.                             key byte = $2B;
  139.                             byte;                /* dh */
  140.                             byte;                /* dv */
  141.                             pstring;
  142.                             
  143.                         case frameRect:
  144.                             key byte = $30;
  145.                             Rect;
  146.                             
  147.                         case paintRect:
  148.                             key byte = $31;
  149.                             Rect;
  150.                             
  151.                         case eraseRect:
  152.                             key byte = $32;
  153.                             Rect;
  154.                             
  155.                         case invertRect:
  156.                             key byte = $33;
  157.                             Rect;
  158.                             
  159.                         case fillRect:
  160.                             key byte = $34;
  161.                             Rect;
  162.                         
  163.                         case frameSameRect:
  164.                             key byte = $38;
  165.                             
  166.                         case paintSameRect:
  167.                             key byte = $39;
  168.                             
  169.                         case eraseSameRect:
  170.                             key byte = $3A;
  171.                             
  172.                         case invertSameRect:
  173.                             key byte = $3B;
  174.                             
  175.                         case fillSameRect:
  176.                             key byte = $3C;
  177.                         
  178.                         case frameRRect:
  179.                             key byte = $40;
  180.                             Rect;
  181.                             
  182.                         case paintRRect:
  183.                             key byte = $41;
  184.                             Rect;
  185.                             
  186.                         case eraseRRect:
  187.                             key byte = $42;
  188.                             Rect;
  189.                             
  190.                         case invertRRect:
  191.                             key byte = $43;
  192.                             Rect;
  193.                             
  194.                         case fillRRect:
  195.                             key byte = $44;
  196.                             Rect;
  197.                             
  198.                         case frameSameRRect:
  199.                             key byte = $48;
  200.                             
  201.                         case paintSameRRect:
  202.                             key byte = $49;
  203.                             
  204.                         case eraseSameRRect:
  205.                             key byte = $4A;
  206.                             
  207.                         case invertSameRRect:
  208.                             key byte = $4B;
  209.                             
  210.                         case fillSameRRect:
  211.                             key byte = $4C;
  212.                             
  213.                         case frameOval:
  214.                             key byte = $50;
  215.                             Rect;
  216.                             
  217.                         case paintOval:
  218.                             key byte = $51;
  219.                             Rect;
  220.                             
  221.                         case eraseOval:
  222.                             key byte = $52;
  223.                             Rect;
  224.                             
  225.                         case invertOval:
  226.                             key byte = $53;
  227.                             Rect;
  228.                             
  229.                         case fillOval:
  230.                             key byte = $54;
  231.                             Rect;
  232.                         
  233.                         case frameSameOval:
  234.                             key byte = $58;
  235.                             
  236.                         case paintSameOval:
  237.                             key byte = $59;
  238.                             
  239.                         case eraseSameOval:
  240.                             key byte = $5A;
  241.                             
  242.                         case invertSameOval:
  243.                             key byte = $5B;
  244.                             
  245.                         case fillSameOval:
  246.                             key byte = $5C;
  247.                         
  248.                         case frameArc:
  249.                             key byte = $60;
  250.                             Rect;
  251.                             integer;                /* startAngle */
  252.                             integer;                /* arcAngle */
  253.                         
  254.                         case paintArc:
  255.                             key byte = $61;
  256.                             Rect;
  257.                             integer;                /* startAngle */
  258.                             integer;                /* arcAngle */
  259.                         
  260.                         case eraseArc:
  261.                             key byte = $62;
  262.                             Rect;
  263.                             integer;                /* startAngle */
  264.                             integer;                /* arcAngle */
  265.                         
  266.                         case invertArc:
  267.                             key byte = $63;
  268.                             Rect;
  269.                             integer;                /* startAngle */
  270.                             integer;                /* arcAngle */
  271.                         
  272.                         case fillArc:
  273.                             key byte = $64;
  274.                             Rect;
  275.                             integer;                /* startAngle */
  276.                             integer;                /* arcAngle */
  277.                         
  278.                         case frameSameArc:
  279.                             key byte = $68;
  280.                             integer;                /* startAngle */
  281.                             integer;                /* arcAngle */
  282.  
  283.                         case paintSameArc:
  284.                             key byte = $69;
  285.                             integer;                /* startAngle */
  286.                             integer;                /* arcAngle */
  287.  
  288.                         case eraseSameArc:
  289.                             key byte = $6A;
  290.                             integer;                /* startAngle */
  291.                             integer;                /* arcAngle */
  292.  
  293.                         case invertSameArc:
  294.                             key byte = $6B;
  295.                             integer;                /* startAngle */
  296.                             integer;                /* arcAngle */
  297.  
  298.                         case fillSameArc:
  299.                             key byte = $6C;
  300.                             integer;                /* startAngle */
  301.                             integer;                /* arcAngle */
  302.                         
  303.                         case framePoly:
  304.                             key byte = $70;
  305.                             integer = $$CountOf(framePoly) * 4 + 10;
  306.                             Rect;                    /* enclosing rectangle */
  307.                             array framePoly {
  308.                                 Point;
  309.                             };
  310.                         
  311.                         case paintPoly:
  312.                             key byte = $71;
  313.                             integer = $$CountOf(framePoly) * 4 + 10;
  314.                             Rect;                    /* enclosing rectangle */
  315.                             array framePoly {
  316.                                 Point;
  317.                             };
  318.                         
  319.                         case erasePoly:
  320.                             key byte = $72;
  321.                             integer = $$CountOf(framePoly) * 4 + 10;
  322.                             Rect;                    /* enclosing rectangle */
  323.                             array framePoly {
  324.                                 Point;
  325.                             };
  326.                         
  327.                         case invertPoly:
  328.                             key byte = $73;
  329.                             integer = $$CountOf(framePoly) * 4 + 10;
  330.                             Rect;                    /* enclosing rectangle */
  331.                             array framePoly {
  332.                                 Point;
  333.                             };
  334.                         
  335.                         case fillPoly:
  336.                             key byte = $74;
  337.                             integer = $$CountOf(framePoly) * 4 + 10;
  338.                             Rect;                    /* enclosing rectangle */
  339.                             array framePoly {
  340.                                 Point;
  341.                             };
  342.                         
  343.                         case frameSamePoly:
  344.                             key byte = $78;
  345.     
  346.                         case paintSamePoly:
  347.                             key byte = $79;
  348.     
  349.                         case eraseSamePoly:
  350.                             key byte = $7A;
  351.     
  352.                         case invertSamePoly:
  353.                             key byte = $7B;
  354.     
  355.                         case fillSamePoly:
  356.                             key byte = $7C;
  357.     
  358.                         case frameRgn:
  359.                             key byte = $80;
  360.     frameRgnStart:            integer = (frameRgnEnd[$$ArrayIndex(OpCodes)] - frameRgnStart[$$ArrayIndex(OpCodes)]) >> 3;
  361.                             Rect;                /* region's enclosing rect */
  362.                             hex string [$$Word(frameRgnStart[$$ArrayIndex(OpCodes)]) - 10];
  363.     frameRgnEnd:
  364.                         case paintRgn:
  365.                             key byte = $81;
  366.     paintRgnStart:            integer = (paintRgnEnd[$$ArrayIndex(OpCodes)] - paintRgnStart[$$ArrayIndex(OpCodes)]) >> 3;
  367.                             Rect;                /* region's enclosing rect */
  368.                             hex string [$$Word(paintRgnStart[$$ArrayIndex(OpCodes)]) - 10];
  369.     paintRgnEnd:
  370.                         case eraseRgn:
  371.                             key byte = $82;
  372.     eraseRgnStart:            integer = (eraseRgnEnd[$$ArrayIndex(OpCodes)] - eraseRgnStart[$$ArrayIndex(OpCodes)]) >> 3;
  373.                             Rect;                /* region's enclosing rect */
  374.                             hex string [$$Word(eraseRgnStart[$$ArrayIndex(OpCodes)]) - 10];
  375.     eraseRgnEnd:
  376.                         case invertRgn:
  377.                             key byte = $83;
  378.     invertRgnStart:            integer = (invertRgnEnd[$$ArrayIndex(OpCodes)] - invertRgnStart[$$ArrayIndex(OpCodes)]) >> 3;
  379.                             Rect;                /* region's enclosing rect */
  380.                             hex string [$$Word(invertRgnStart[$$ArrayIndex(OpCodes)]) - 10];
  381.     invertRgnEnd:
  382.                         case fillRgn:
  383.                             key byte = $84;
  384.     fillRgnStart:            integer = (fillRgnEnd[$$ArrayIndex(OpCodes)] - fillRgnStart[$$ArrayIndex(OpCodes)]) >> 3;
  385.                             Rect;                /* region's enclosing rect */
  386.                             hex string [$$Word(fillRgnStart[$$ArrayIndex(OpCodes)]) - 10];
  387.     fillRgnEnd:
  388.                         case frameSameRgn:
  389.                             key byte = $88;
  390.  
  391.                         case paintSameRgn:
  392.                             key byte = $89;
  393.  
  394.                         case eraseSameRgn:
  395.                             key byte = $8A;
  396.  
  397.                         case invertSameRgn:
  398.                             key byte = $8B;
  399.  
  400.                         case fillSameRgn:
  401.                             key byte = $8C;
  402.  
  403.                         case bitsRect:
  404.                             key byte = $90;
  405.     BitsRectRowBytes:        integer;                    /* row bytes */
  406.     BitsRectBounds:            Rect;                        /* bounds */
  407.                             Rect;                        /* srcRect */
  408.                             Rect;                        /* destRect */
  409.                             integer        srcCopy, srcOr, srcXor, srcBic,    /* mode */
  410.                                         notSrcCopy, notSrcOr, notSrcXor,
  411.                                         notSrcBic, patCopy, patOr, patXor,
  412.                                         patBic, notPatCopy, notPatOr, notPatBic;
  413.                             hex string [($$BitField(BitsRectBounds[$$ArrayIndex(OpCodes)],32,16)
  414.                                         - $$BitField(BitsRectBounds[$$ArrayIndex(OpCodes)],0,16))
  415.                                         * $$Word(BitsRectRowBytes[$$ArrayIndex(OpCodes)])];
  416.  
  417.                         case bitsRgn:
  418.                             key byte = $91;
  419.     BitsRgnRowBytes:        integer;                    /* row bytes */
  420.     BitsRgnBounds:            Rect;                        /* bounds */
  421.                             Rect;                        /* srcRect */
  422.                             Rect;                        /* destRect */
  423.                             integer        srcCopy, srcOr, srcXor, srcBic,    /* mode */
  424.                                         notSrcCopy, notSrcOr, notSrcXor,
  425.                                         notSrcBic, patCopy, patOr, patXor,
  426.                                         patBic, notPatCopy, notPatOr, notPatBic;
  427.     bitsRgnStart:            integer = (bitsRgnEnd[$$ArrayIndex(OpCodes)] - bitsRgnStart[$$ArrayIndex(OpCodes)]) >> 3;
  428.                             Rect;                /* region's enclosing rect */
  429.                             hex string [$$Word(bitsRgnStart[$$ArrayIndex(OpCodes)]) - 10];
  430.     bitsRgnEnd:
  431.                             hex string [($$BitField(BitsRgnBounds[$$ArrayIndex(OpCodes)],32,16)
  432.                                         - $$BitField(BitsRgnBounds[$$ArrayIndex(OpCodes)],0,16))
  433.                                         * $$Word(BitsRgnRowBytes[$$ArrayIndex(OpCodes)])];
  434.  
  435.                         case packBitsRect:
  436.                             key byte = $98;
  437.     PackBitsRectRowBytes:    integer;                    /* row bytes */
  438.     PackBitsRectBounds:        Rect;                        /* bounds */
  439.                             Rect;                        /* srcRect */
  440.                             Rect;                        /* destRect */
  441.                             integer        srcCopy, srcOr, srcXor, srcBic,    /* mode */
  442.                                         notSrcCopy, notSrcOr, notSrcXor,
  443.                                         notSrcBic, patCopy, patOr, patXor,
  444.                                         patBic, notPatCopy, notPatOr, notPatBic;
  445.     PackBitsBits:            hex string [$$PackedSize(PackBitsBits[$$ArrayIndex(OpCodes)],
  446.                                         $$Word(PackBitsRectRowBytes[$$ArrayIndex(OpCodes)]),
  447.                                         ($$BitField(PackBitsRectBounds[$$ArrayIndex(OpCodes)],32,16)
  448.                                         - $$BitField(PackBitsRectBounds[$$ArrayIndex(OpCodes)],0,16)))];
  449.  
  450.                         case packBitsRgn:
  451.                             key byte = $99;
  452.     packBitsRgnRowBytes:    integer;                    /* row bytes */
  453.     packBitsRgnBounds:        Rect;                        /* bounds */
  454.                             Rect;                        /* srcRect */
  455.                             Rect;                        /* destRect */
  456.                             integer        srcCopy, srcOr, srcXor, srcBic,    /* mode */
  457.                                         notSrcCopy, notSrcOr, notSrcXor,
  458.                                         notSrcBic, patCopy, patOr, patXor,
  459.                                         patBic, notPatCopy, notPatOr, notPatBic;
  460.     packBitsRgnStart:        integer = (packBitsRgnEnd[$$ArrayIndex(OpCodes)] - packBitsRgnStart[$$ArrayIndex(OpCodes)]) >> 3;
  461.                             Rect;                /* region's enclosing rect */
  462.                             hex string [$$Word(packBitsRgnStart[$$ArrayIndex(OpCodes)]) - 10];
  463.     packBitsRgnEnd:            hex string [$$PackedSize(packBitsRgnEnd[$$ArrayIndex(OpCodes)],
  464.                                         $$Word(packBitsRgnRowBytes[$$ArrayIndex(OpCodes)]),
  465.                                         ($$BitField(packBitsRgnBounds[$$ArrayIndex(OpCodes)],32,16)
  466.                                         - $$BitField(packBitsRgnBounds[$$ArrayIndex(OpCodes)],0,16)))];
  467.     
  468.                         case shortComment:
  469.                             key byte = $A0;
  470.                             integer;            /* kind */
  471.  
  472.                         case longComment:
  473.                             key byte = $A1;
  474.                             integer;            /* kind */
  475.     longCommentStart:        integer = (longCommentEnd[$$ArrayIndex(OpCodes)] - longCommentStart[$$ArrayIndex(OpCodes)] - 16) >> 3;
  476.                             hex string [$$Word(longCommentStart[$$ArrayIndex(OpCodes)])];
  477.     longCommentEnd:
  478.                     };
  479.                 };
  480.                 byte = $FF;     /* End of picture */
  481.                 
  482.             case VersionTwo:
  483.                 key longint = $001102ff;        /* Version op + version */
  484.                 array OpCodes {
  485.                     switch {
  486.                         case Clip:
  487.                             key integer = $0001;
  488.     ClipStart:                integer = (ClipEnd[$$ArrayIndex(OpCodes)] - ClipStart[$$ArrayIndex(OpCodes)]) >> 3;
  489.                             Rect;                /* region's enclosing rect */
  490.                             hex string [$$Word(ClipStart[$$ArrayIndex(OpCodes)]) - 10];
  491.     ClipEnd:
  492.                         case BkPat:
  493.                             key integer = $0002;
  494.                             hex string [8];
  495.                         
  496.                         case TxFont:
  497.                             key integer = $0003;
  498.                             integer;            /* font */
  499.                         
  500.                         case TxFace:
  501.                             key integer = $0004;
  502.                             unsigned hex byte;    /* text face */
  503.                         
  504.                         case TxMode:
  505.                             key integer = $0005;
  506.                             integer        srcCopy, srcOr, srcXor, srcBic,    /* mode */
  507.                                         notSrcCopy, notSrcOr, notSrcXor,
  508.                                         notSrcBic, patCopy, patOr, patXor,
  509.                                         patBic, notPatCopy, notPatOr, notPatBic;
  510.                         
  511.                         case SpExtra:
  512.                             key integer = $0006;
  513.                             unsigned hex longint;
  514.                         
  515.                         case PnSize:
  516.                             key integer = $0007;
  517.                             Point;
  518.                         
  519.                         case PnMode:
  520.                             key integer = $0008;
  521.                             unsigned hex integer;
  522.                         
  523.                         case PnPat:
  524.                             key integer = $0009;
  525.                             hex string [8];
  526.                         
  527.                         case FillPat:
  528.                             key integer = $000A;
  529.                             hex string [8];
  530.                         
  531.                         case OvSize:
  532.                             key integer = $000B;
  533.                             Point;
  534.                         
  535.                         case Origin:
  536.                             key integer = $000C;
  537.                             integer;            /* dh */
  538.                             integer;            /* dv */
  539.                         
  540.                         case TxSize:
  541.                             key integer = $000D;
  542.                             integer;
  543.                         
  544.                         case FgColor:
  545.                             key integer = $000E;
  546.                             longint;
  547.                         
  548.                         case BkColor:
  549.                             key integer = $000F;
  550.                             longint;
  551.                         
  552.                         case TxRatio:
  553.                             key integer = $0010;
  554.                             Point;                /* numer */
  555.                             Point;                /* denom */
  556.                         
  557.                         case Version:
  558.                             key integer = $0011;
  559.                             byte;
  560.  
  561.                         case BkPixPat:
  562.                             key integer = $0012;
  563.                             switch {
  564.                                 case newPattern:
  565.                                     key integer = 1;
  566.                                     hex string [8];            /* old-style pattern    */
  567.                                     unsigned bitstring[1] = 1;                                /* New pixMap flag        */
  568.                                     unsigned bitstring[2] = 0;                                /* Must be 0            */
  569.     BkPixPatpMapRowBytes:            unsigned bitstring[13];                                    /* Offset to next row    */
  570.     BkPixPatBounds:                    rect;                                                    /* Bitmap bounds        */
  571.                                     integer;                                                /* pixMap vers number    */
  572.                                     integer    unpacked;                                        /* Packing format        */
  573.                                     unsigned longint;                                        /* Size of pixel data    */
  574.                                     unsigned hex longint;                                    /* h. resolution (ppi) (fixed) */
  575.                                     unsigned hex longint;                                    /* v. resolution (ppi) (fixed) */
  576.                                     integer            chunky, chunkyPlanar, planar;            /* Pixel storage format    */
  577.                                     integer;                                                /* # bits in pixel        */
  578.                                     integer;                                                /* # components in pixel*/
  579.                                     integer;                                                /* # bits per field        */
  580.                                     unsigned longint;                                        /* Offset to next plane    */
  581.                                     unsigned longint;                                        /* Offset to color table*/
  582.                                     fill long;                                                /* Reserved                */
  583.                                     /* Color Table */
  584.                                     unsigned hex longint;                                    /* ctSeed                */
  585.                                     integer;                                                /* ctFlags                */
  586.                                     integer = $$Countof(ColorSpec) - 1;                        /* ctSize                */
  587.                                     wide array ColorSpec {
  588.                                             integer;                                        /* value                */
  589.                                             unsigned integer;                                /* RGB:    red                */
  590.                                             unsigned integer;                                /*        green            */
  591.                                             unsigned integer;                                /*        blue            */
  592.                                     };
  593.                                     /* If rowBytes < 8 then data is unpacked,
  594.                                        if >= 8, then data is packed */
  595.     BkPixPatBits:                    hex string [($$BitField(BkPixPatpMapRowBytes[$$ArrayIndex(OpCodes)],0,13) < 8) *
  596.                                                 $$BitField(BkPixPatpMapRowBytes[$$ArrayIndex(OpCodes)],0,13) +
  597.                                                 ($$BitField(BkPixPatpMapRowBytes[$$ArrayIndex(OpCodes)],0,13) >= 8) *
  598.                                                 $$PackedSize(BkPixPatBits[$$ArrayIndex(OpCodes)],
  599.                                                 $$BitField(BkPixPatpMapRowBytes[$$ArrayIndex(OpCodes)],0,13),
  600.                                                 ($$BitField(BkPixPatBounds[$$ArrayIndex(OpCodes)],32,16)
  601.                                                 - $$BitField(BkPixPatBounds[$$ArrayIndex(OpCodes)],0,16)))];
  602.                                 
  603.                                 case ditherPattern:
  604.                                     key integer = 2;
  605.                                     hex string [8];            /* old-style pattern    */
  606.                                     unsigned integer;        /* RGB:    red                */
  607.                                     unsigned integer;        /*        green            */
  608.                                     unsigned integer;        /*        blue            */
  609.                             };
  610.  
  611.                         case PnPixPat:
  612.                             key integer = $0013;
  613.                             switch {
  614.                                 case newPattern:
  615.                                     key integer = 1;
  616.                                     hex string [8];            /* old-style pattern    */
  617.                                     unsigned bitstring[1] = 1;                                /* New pixMap flag        */
  618.                                     unsigned bitstring[2] = 0;                                /* Must be 0            */
  619.     PnPixPatpMapRowBytes:            unsigned bitstring[13];                                    /* Offset to next row    */
  620.     PnPixPatBounds:                    rect;                                                    /* Bitmap bounds        */
  621.                                     integer;                                                /* pixMap vers number    */
  622.                                     integer    unpacked;                                        /* Packing format        */
  623.                                     unsigned longint;                                        /* Size of pixel data    */
  624.                                     unsigned hex longint;                                    /* h. resolution (ppi) (fixed) */
  625.                                     unsigned hex longint;                                    /* v. resolution (ppi) (fixed) */
  626.                                     integer            chunky, chunkyPlanar, planar;            /* Pixel storage format    */
  627.                                     integer;                                                /* # bits in pixel        */
  628.                                     integer;                                                /* # components in pixel*/
  629.                                     integer;                                                /* # bits per field        */
  630.                                     unsigned longint;                                        /* Offset to next plane    */
  631.                                     unsigned longint;                                        /* Offset to color table*/
  632.                                     fill long;                                                /* Reserved                */
  633.                                     /* Color Table */
  634.                                     unsigned hex longint;                                    /* ctSeed                */
  635.                                     integer;                                                /* ctFlags                */
  636.                                     integer = $$Countof(ColorSpec) - 1;                        /* ctSize                */
  637.                                     wide array ColorSpec {
  638.                                             integer;                                        /* value                */
  639.                                             unsigned integer;                                /* RGB:    red                */
  640.                                             unsigned integer;                                /*        green            */
  641.                                             unsigned integer;                                /*        blue            */
  642.                                     };
  643.                                     /* If rowBytes < 8 then data is unpacked,
  644.                                        if >= 8, then data is packed */
  645.     PnPixPatBits:                    hex string [($$BitField(PnPixPatpMapRowBytes[$$ArrayIndex(OpCodes)],0,13) < 8) *
  646.                                                 $$BitField(PnPixPatpMapRowBytes[$$ArrayIndex(OpCodes)],0,13) +
  647.                                                 ($$BitField(PnPixPatpMapRowBytes[$$ArrayIndex(OpCodes)],0,13) >= 8) *
  648.                                                 $$PackedSize(PnPixPatBits[$$ArrayIndex(OpCodes)],
  649.                                                 $$BitField(PnPixPatpMapRowBytes[$$ArrayIndex(OpCodes)],0,13),
  650.                                                 ($$BitField(PnPixPatBounds[$$ArrayIndex(OpCodes)],32,16)
  651.                                                 - $$BitField(PnPixPatBounds[$$ArrayIndex(OpCodes)],0,16)))];
  652.                                 
  653.                                 case ditherPattern:
  654.                                     key integer = 2;
  655.                                     hex string [8];            /* old-style pattern    */
  656.                                     unsigned integer;        /* RGB:    red                */
  657.                                     unsigned integer;        /*        green            */
  658.                                     unsigned integer;        /*        blue            */
  659.                             };
  660.  
  661.                         case FillPixPat:
  662.                             key integer = $0014;
  663.                             switch {
  664.                                 case newPattern:
  665.                                     key integer = 1;
  666.                                     hex string [8];            /* old-style pattern    */
  667.                                     unsigned bitstring[1] = 1;                                /* New pixMap flag        */
  668.                                     unsigned bitstring[2] = 0;                                /* Must be 0            */
  669.     FillPixPatpMapRowBytes:            unsigned bitstring[13];                                    /* Offset to next row    */
  670.     FillPixPatBounds:                    rect;                                                    /* Bitmap bounds        */
  671.                                     integer;                                                /* pixMap vers number    */
  672.                                     integer    unpacked;                                        /* Packing format        */
  673.                                     unsigned longint;                                        /* Size of pixel data    */
  674.                                     unsigned hex longint;                                    /* h. resolution (ppi) (fixed) */
  675.                                     unsigned hex longint;                                    /* v. resolution (ppi) (fixed) */
  676.                                     integer            chunky, chunkyPlanar, planar;            /* Pixel storage format    */
  677.                                     integer;                                                /* # bits in pixel        */
  678.                                     integer;                                                /* # components in pixel*/
  679.                                     integer;                                                /* # bits per field        */
  680.                                     unsigned longint;                                        /* Offset to next plane    */
  681.                                     unsigned longint;                                        /* Offset to color table*/
  682.                                     fill long;                                                /* Reserved                */
  683.                                     /* Color Table */
  684.                                     unsigned hex longint;                                    /* ctSeed                */
  685.                                     integer;                                                /* ctFlags                */
  686.                                     integer = $$Countof(ColorSpec) - 1;                        /* ctSize                */
  687.                                     wide array ColorSpec {
  688.                                             integer;                                        /* value                */
  689.                                             unsigned integer;                                /* RGB:    red                */
  690.                                             unsigned integer;                                /*        green            */
  691.                                             unsigned integer;                                /*        blue            */
  692.                                     };
  693.                                     /* If rowBytes < 8 then data is unpacked,
  694.                                        if >= 8, then data is packed */
  695.     FillPixPatBits:                    hex string [($$BitField(FillPixPatpMapRowBytes[$$ArrayIndex(OpCodes)],0,13) < 8) *
  696.                                                 $$BitField(FillPixPatpMapRowBytes[$$ArrayIndex(OpCodes)],0,13) +
  697.                                                 ($$BitField(FillPixPatpMapRowBytes[$$ArrayIndex(OpCodes)],0,13) >= 8) *
  698.                                                 $$PackedSize(FillPixPatBits[$$ArrayIndex(OpCodes)],
  699.                                                 $$BitField(FillPixPatpMapRowBytes[$$ArrayIndex(OpCodes)],0,13),
  700.                                                 ($$BitField(FillPixPatBounds[$$ArrayIndex(OpCodes)],32,16)
  701.                                                 - $$BitField(FillPixPatBounds[$$ArrayIndex(OpCodes)],0,16)))];
  702.                                 
  703.                                 case ditherPattern:
  704.                                     key integer = 2;
  705.                                     hex string [8];            /* old-style pattern    */
  706.                                     unsigned integer;        /* RGB:    red                */
  707.                                     unsigned integer;        /*        green            */
  708.                                     unsigned integer;        /*        blue            */
  709.                             };
  710.                         
  711.                         case PnLocHFrac:
  712.                             key integer = $0015;
  713.                             unsigned hex integer;
  714.                         
  715.                         case ChExtra:
  716.                             key integer = $0016;
  717.                             integer;                        /* extra for each character */
  718.                         
  719.                         case AppleReserved0017:
  720.                             key integer = $0017;
  721.                             
  722.                         case AppleReserved0018:
  723.                             key integer = $0018;
  724.                             
  725.                         case AppleReserved0019:
  726.                             key integer = $0019;
  727.                         
  728.                         case RGBFgCol:
  729.                             key integer = $001A;
  730.                             unsigned integer;        /* RGB:    red                */
  731.                             unsigned integer;        /*        green            */
  732.                             unsigned integer;        /*        blue            */
  733.                             
  734.                         case RGBBkCol:
  735.                             key integer = $001B;
  736.                             unsigned integer;        /* RGB:    red                */
  737.                             unsigned integer;        /*        green            */
  738.                             unsigned integer;        /*        blue            */
  739.                             
  740.                         case HiliteMode:
  741.                             key integer = $001C;
  742.                         
  743.                         case HiliteColor:
  744.                             key integer = $001D;
  745.                             unsigned integer;        /* RGB:    red                */
  746.                             unsigned integer;        /*        green            */
  747.                             unsigned integer;        /*        blue            */
  748.                         
  749.                         case DefHilite:
  750.                             key integer = $001E;
  751.                         
  752.                         case OpColor:
  753.                             key integer = $001F;
  754.                             unsigned integer;        /* RGB:    red                */
  755.                             unsigned integer;        /*        green            */
  756.                             unsigned integer;        /*        blue            */
  757.                         
  758.                         case Line:
  759.                             key integer = $0020;
  760.                             Point;                    /* pnLoc */
  761.                             Point;                    /* newPt */
  762.                             
  763.                         case LineFrom:
  764.                             key integer = $0021;
  765.                             Point;                    /* newPt */
  766.                         
  767.                         case ShortLine:
  768.                             key integer = $0022;
  769.                             Point;                    /* pnLoc */
  770.                             byte;                    /* dh */
  771.                             byte;                    /* dv */
  772.                         
  773.                         case ShortLineFrom:
  774.                             key integer = $0023;
  775.                             byte;                    /* dh */
  776.                             byte;                    /* dv */
  777.                         
  778.                         case AppleReserved0024:
  779.                             key integer = $0024;
  780.                 AR24:        unsigned integer = (AR24End - AR24) / 8 - 2;
  781.                             hex string [$$Word(AR24)];
  782.                 AR24End:
  783.                         
  784.                         case AppleReserved0025:
  785.                             key integer = $0025;
  786.                 AR25:        unsigned integer = (AR25End - AR25) / 8 - 2;
  787.                             hex string [$$Word(AR25)];
  788.                 AR25End:
  789.                         
  790.                         case AppleReserved0026:
  791.                             key integer = $0026;
  792.                 AR26:        unsigned integer = (AR26End - AR26) / 8 - 2;
  793.                             hex string [$$Word(AR26)];
  794.                 AR26End:
  795.                         
  796.                         case AppleReserved0027:
  797.                             key integer = $0027;
  798.                 AR27:        unsigned integer = (AR27End - AR27) / 8 - 2;
  799.                             hex string [$$Word(AR27)];
  800.                 AR27End:
  801.                         
  802.                         case LongText:
  803.                             key integer = $0028;
  804.                             Point;                /* txLoc */
  805.                             pstring;            /* text */
  806.                         
  807.                         case DHText:
  808.                             key integer = $0029;
  809.                             byte;                /* dh */
  810.                             pstring;            /* text */
  811.  
  812.                         case DVText:
  813.                             key integer = $002A;
  814.                             byte;                /* dv */
  815.                             pstring;            /* text */
  816.  
  817.                         case DHDVText:
  818.                             key integer = $002A;
  819.                             byte;                /* dh */
  820.                             byte;                /* dv */
  821.                             pstring;            /* text */
  822.  
  823.                         case AppleReserved002C:
  824.                             key integer = $002C;
  825.                 AR2C:        unsigned integer = (AR2CEnd - AR2C) / 8 - 2;
  826.                             hex string [$$Word(AR2C)];
  827.                 AR2CEnd:
  828.                         
  829.                         case AppleReserved002D:
  830.                             key integer = $002D;
  831.                 AR2D:        unsigned integer = (AR2DEnd - AR2D) / 8 - 2;
  832.                             hex string [$$Word(AR2D)];
  833.                 AR2DEnd:
  834.                         
  835.                         case AppleReserved002E:
  836.                             key integer = $002E;
  837.                 AR2E:        unsigned integer = (AR2EEnd - AR2E) / 8 - 2;
  838.                             hex string [$$Word(AR2E)];
  839.                 AR2EEnd:
  840.                         
  841.                         case AppleReserved002F:
  842.                             key integer = $002F;
  843.                 AR2F:        unsigned integer = (AR2FEnd - AR2F) / 8 - 2;
  844.                             hex string [$$Word(AR2F)];
  845.                 AR2FEnd:
  846.                         
  847.                         case FrameRect:
  848.                             key integer = $0030;
  849.                             Rect;
  850.                             
  851.                         case PaintRect:
  852.                             key integer = $0031;
  853.                             Rect;
  854.                             
  855.                         case EraseRect:
  856.                             key integer = $0032;
  857.                             Rect;
  858.                             
  859.                         case InvertRect:
  860.                             key integer = $0033;
  861.                             Rect;
  862.                             
  863.                         case FillRect:
  864.                             key integer = $0034;
  865.                             Rect;
  866.                             
  867.                         case AppleReserved0035:
  868.                             key integer = $0035;
  869.                             Rect;
  870.                             
  871.                         case AppleReserved0036:
  872.                             key integer = $0036;
  873.                             Rect;
  874.                             
  875.                         case AppleReserved0037:
  876.                             key integer = $0037;
  877.                             Rect;
  878.                         
  879.                         case FrameSameRect:
  880.                             key integer = $0038;
  881.                         
  882.                         case PaintSameRect:
  883.                             key integer = $0039;
  884.                         
  885.                         case EraseSameRect:
  886.                             key integer = $003A;
  887.                         
  888.                         case InvertSameRect:
  889.                             key integer = $003B;
  890.                         
  891.                         case FillSameRect:
  892.                             key integer = $003C;
  893.                         
  894.                         case AppleReserved003D:
  895.                             key integer = $003D;
  896.                         
  897.                         case AppleReserved003E:
  898.                             key integer = $003E;
  899.                         
  900.                         case AppleReserved003F:
  901.                             key integer = $003F;
  902.                         
  903.                         case FrameRRect:
  904.                             key integer = $0040;
  905.                             Rect;
  906.                             
  907.                         case PaintRRect:
  908.                             key integer = $0041;
  909.                             Rect;
  910.                             
  911.                         case EraseRRect:
  912.                             key integer = $0042;
  913.                             Rect;
  914.                             
  915.                         case InvertRRect:
  916.                             key integer = $0043;
  917.                             Rect;
  918.                             
  919.                         case FillRRect:
  920.                             key integer = $0044;
  921.                             Rect;
  922.                             
  923.                         case AppleReserved0045:
  924.                             key integer = $0045;
  925.                             Rect;
  926.                             
  927.                         case AppleReserved0046:
  928.                             key integer = $0046;
  929.                             Rect;
  930.                             
  931.                         case AppleReserved0047:
  932.                             key integer = $0047;
  933.                             Rect;
  934.                         
  935.                         case FrameSameRRect:
  936.                             key integer = $0048;
  937.                         
  938.                         case PaintSameRRect:
  939.                             key integer = $0049;
  940.                         
  941.                         case EraseSameRRect:
  942.                             key integer = $004A;
  943.                         
  944.                         case InvertSameRRect:
  945.                             key integer = $004B;
  946.                         
  947.                         case FillSameRRect:
  948.                             key integer = $004C;
  949.                         
  950.                         case AppleReserved004D:
  951.                             key integer = $004D;
  952.                         
  953.                         case AppleReserved004E:
  954.                             key integer = $004E;
  955.                         
  956.                         case AppleReserved004F:
  957.                             key integer = $004F;
  958.                         
  959.                         case FrameOval:
  960.                             key integer = $0050;
  961.                             Rect;
  962.                             
  963.                         case PaintOval:
  964.                             key integer = $0051;
  965.                             Rect;
  966.                             
  967.                         case EraseOval:
  968.                             key integer = $0052;
  969.                             Rect;
  970.                             
  971.                         case InvertOval:
  972.                             key integer = $0053;
  973.                             Rect;
  974.                             
  975.                         case FillOval:
  976.                             key integer = $0054;
  977.                             Rect;
  978.                             
  979.                         case AppleReserved0055:
  980.                             key integer = $0055;
  981.                             Rect;
  982.                             
  983.                         case AppleReserved0056:
  984.                             key integer = $0056;
  985.                             Rect;
  986.                             
  987.                         case AppleReserved0057:
  988.                             key integer = $0057;
  989.                             Rect;
  990.                         
  991.                         case FrameSameOval:
  992.                             key integer = $0058;
  993.                         
  994.                         case PaintSameOval:
  995.                             key integer = $0059;
  996.                         
  997.                         case EraseSameOval:
  998.                             key integer = $005A;
  999.                         
  1000.                         case InvertSameOval:
  1001.                             key integer = $005B;
  1002.                         
  1003.                         case FillSameOval:
  1004.                             key integer = $005C;
  1005.                         
  1006.                         case AppleReserved005D:
  1007.                             key integer = $005D;
  1008.                         
  1009.                         case AppleReserved005E:
  1010.                             key integer = $005E;
  1011.                         
  1012.                         case frameArc:
  1013.                             key integer = $0060;
  1014.                             Rect;
  1015.                             integer;                /* startAngle */
  1016.                             integer;                /* arcAngle */
  1017.                         
  1018.                         case paintArc:
  1019.                             key integer = $0061;
  1020.                             Rect;
  1021.                             integer;                /* startAngle */
  1022.                             integer;                /* arcAngle */
  1023.                         
  1024.                         case eraseArc:
  1025.                             key integer = $0062;
  1026.                             Rect;
  1027.                             integer;                /* startAngle */
  1028.                             integer;                /* arcAngle */
  1029.                         
  1030.                         case invertArc:
  1031.                             key integer = $0063;
  1032.                             Rect;
  1033.                             integer;                /* startAngle */
  1034.                             integer;                /* arcAngle */
  1035.                         
  1036.                         case fillArc:
  1037.                             key integer = $0064;
  1038.                             Rect;
  1039.                             integer;                /* startAngle */
  1040.                             integer;                /* arcAngle */
  1041.                         
  1042.                         case AppleReserved0065:
  1043.                             key integer = $0065;
  1044.                             Rect;
  1045.                             integer;                /* startAngle */
  1046.                             integer;                /* arcAngle */
  1047.                         
  1048.                         case AppleReserved0066:
  1049.                             key integer = $0066;
  1050.                             Rect;
  1051.                             integer;                /* startAngle */
  1052.                             integer;                /* arcAngle */
  1053.                         
  1054.                         case AppleReserved0067:
  1055.                             key integer = $0067;
  1056.                             Rect;
  1057.                             integer;                /* startAngle */
  1058.                             integer;                /* arcAngle */
  1059.                         
  1060.                         case frameSameArc:
  1061.                             key integer = $0068;
  1062.                             integer;                /* startAngle */
  1063.                             integer;                /* arcAngle */
  1064.  
  1065.                         case paintSameArc:
  1066.                             key integer = $0069;
  1067.                             integer;                /* startAngle */
  1068.                             integer;                /* arcAngle */
  1069.  
  1070.                         case eraseSameArc:
  1071.                             key integer = $006A;
  1072.                             integer;                /* startAngle */
  1073.                             integer;                /* arcAngle */
  1074.  
  1075.                         case invertSameArc:
  1076.                             key integer = $006B;
  1077.                             integer;                /* startAngle */
  1078.                             integer;                /* arcAngle */
  1079.  
  1080.                         case fillSameArc:
  1081.                             key integer = $006C;
  1082.                             integer;                /* startAngle */
  1083.                             integer;                /* arcAngle */
  1084.                         
  1085.                         case AppleReserved006D:
  1086.                             key integer = $006D;
  1087.                             integer;                /* startAngle */
  1088.                             integer;                /* arcAngle */
  1089.                         
  1090.                         case AppleReserved006E:
  1091.                             key integer = $006E;
  1092.                             integer;                /* startAngle */
  1093.                             integer;                /* arcAngle */
  1094.                         
  1095.                         case AppleReserved006F:
  1096.                             key integer = $006F;
  1097.                             integer;                /* startAngle */
  1098.                             integer;                /* arcAngle */
  1099.                         
  1100.                         case framePoly:
  1101.                             key integer = $0070;
  1102.                             integer = $$CountOf(framePoly) * 4 + 10;
  1103.                             Rect;                    /* enclosing rectangle */
  1104.                             array framePoly {
  1105.                                 Point;
  1106.                             };
  1107.                         
  1108.                         case paintPoly:
  1109.                             key integer = $0071;
  1110.                             integer = $$CountOf(framePoly) * 4 + 10;
  1111.                             Rect;                    /* enclosing rectangle */
  1112.                             array framePoly {
  1113.                                 Point;
  1114.                             };
  1115.                         
  1116.                         case erasePoly:
  1117.                             key integer = $0072;
  1118.                             integer = $$CountOf(framePoly) * 4 + 10;
  1119.                             Rect;                    /* enclosing rectangle */
  1120.                             array framePoly {
  1121.                                 Point;
  1122.                             };
  1123.                         
  1124.                         case invertPoly:
  1125.                             key integer = $0073;
  1126.                             integer = $$CountOf(framePoly) * 4 + 10;
  1127.                             Rect;                    /* enclosing rectangle */
  1128.                             array framePoly {
  1129.                                 Point;
  1130.                             };
  1131.                         
  1132.                         case fillPoly:
  1133.                             key integer = $0074;
  1134.                             integer = $$CountOf(framePoly) * 4 + 10;
  1135.                             Rect;                    /* enclosing rectangle */
  1136.                             array framePoly {
  1137.                                 Point;
  1138.                             };
  1139.                         
  1140.                         case AppleReserved0075:
  1141.                             key integer = $0075;
  1142.                             integer = $$CountOf(framePoly) * 4 + 10;
  1143.                             Rect;                    /* enclosing rectangle */
  1144.                             array framePoly {
  1145.                                 Point;
  1146.                             };
  1147.                         
  1148.                         case AppleReserved0076:
  1149.                             key integer = $0076;
  1150.                             integer = $$CountOf(framePoly) * 4 + 10;
  1151.                             Rect;                    /* enclosing rectangle */
  1152.                             array framePoly {
  1153.                                 Point;
  1154.                             };
  1155.                         
  1156.                         case AppleReserved0077:
  1157.                             key integer = $0077;
  1158.                             integer = $$CountOf(framePoly) * 4 + 10;
  1159.                             Rect;                    /* enclosing rectangle */
  1160.                             array framePoly {
  1161.                                 Point;
  1162.                             };
  1163.                         
  1164.                         case frameSamePoly:
  1165.                             key integer = $0078;
  1166.     
  1167.                         case paintSamePoly:
  1168.                             key integer = $0079;
  1169.     
  1170.                         case eraseSamePoly:
  1171.                             key integer = $007A;
  1172.     
  1173.                         case invertSamePoly:
  1174.                             key integer = $007B;
  1175.     
  1176.                         case fillSamePoly:
  1177.                             key integer = $007C;
  1178.     
  1179.                         case AppleReserved007D:
  1180.                             key integer = $007D;
  1181.     
  1182.                         case AppleReserved007E:
  1183.                             key integer = $007E;
  1184.     
  1185.                         case AppleReserved007F:
  1186.                             key integer = $007F;
  1187.     
  1188.                         case frameRgn:
  1189.                             key integer = $0080;
  1190.     frameRgnStart2:            integer = (frameRgnEnd2[$$ArrayIndex(OpCodes)] - frameRgnStart2[$$ArrayIndex(OpCodes)]) >> 3;
  1191.                             Rect;                /* region's enclosing rect */
  1192.                             hex string [$$Word(frameRgnStart2[$$ArrayIndex(OpCodes)]) - 10];
  1193.     frameRgnEnd2:
  1194.                         case paintRgn:
  1195.                             key integer = $0081;
  1196.     paintRgnStart2:            integer = (paintRgnEnd2[$$ArrayIndex(OpCodes)] - paintRgnStart2[$$ArrayIndex(OpCodes)]) >> 3;
  1197.                             Rect;                /* region's enclosing rect */
  1198.                             hex string [$$Word(paintRgnStart2[$$ArrayIndex(OpCodes)]) - 10];
  1199.     paintRgnEnd2:
  1200.                         case eraseRgn:
  1201.                             key integer = $0082;
  1202.     eraseRgnStart2:            integer = (eraseRgnEnd2[$$ArrayIndex(OpCodes)] - eraseRgnStart2[$$ArrayIndex(OpCodes)]) >> 3;
  1203.                             Rect;                /* region's enclosing rect */
  1204.                             hex string [$$Word(eraseRgnStart2[$$ArrayIndex(OpCodes)]) - 10];
  1205.     eraseRgnEnd2:
  1206.                         case invertRgn:
  1207.                             key integer = $0083;
  1208.     invertRgnStart2:        integer = (invertRgnEnd2[$$ArrayIndex(OpCodes)] - invertRgnStart2[$$ArrayIndex(OpCodes)]) >> 3;
  1209.                             Rect;                /* region's enclosing rect */
  1210.                             hex string [$$Word(invertRgnStart2[$$ArrayIndex(OpCodes)]) - 10];
  1211.     invertRgnEnd2:
  1212.                         case fillRgn:
  1213.                             key integer = $0084;
  1214.     fillRgnStart2:            integer = (fillRgnEnd2[$$ArrayIndex(OpCodes)] - fillRgnStart2[$$ArrayIndex(OpCodes)]) >> 3;
  1215.                             Rect;                /* region's enclosing rect */
  1216.                             hex string [$$Word(fillRgnStart2[$$ArrayIndex(OpCodes)]) - 10];
  1217.     fillRgnEnd2:
  1218.                         case AppleReserved0085:
  1219.                             key integer = $0085;
  1220.     AppleReserved0085Start:integer = (AppleReserved0085End[$$ArrayIndex(OpCodes)] - AppleReserved0085Start[$$ArrayIndex(OpCodes)]) >> 3;
  1221.                             Rect;                /* region's enclosing rect */
  1222.                             hex string [$$Word(AppleReserved0085Start[$$ArrayIndex(OpCodes)]) - 10];
  1223.     AppleReserved0085End:
  1224.                         case AppleReserved0086:
  1225.                             key integer = $0086;
  1226.     AppleReserved0086Start:    integer = (AppleReserved0086End[$$ArrayIndex(OpCodes)] - AppleReserved0086Start[$$ArrayIndex(OpCodes)]) >> 3;
  1227.                             Rect;                /* region's enclosing rect */
  1228.                             hex string [$$Word(AppleReserved0086Start[$$ArrayIndex(OpCodes)]) - 10];
  1229.     AppleReserved0086End:
  1230.                         case AppleReserved0087:
  1231.                             key integer = $0087;
  1232.     AppleReserved0087Start:    integer = (AppleReserved0087End[$$ArrayIndex(OpCodes)] - AppleReserved0087Start[$$ArrayIndex(OpCodes)]) >> 3;
  1233.                             Rect;                /* region's enclosing rect */
  1234.                             hex string [$$Word(AppleReserved0087Start[$$ArrayIndex(OpCodes)]) - 10];
  1235.     AppleReserved0087End:
  1236.                         case frameSameRgn:
  1237.                             key integer = $0088;
  1238.  
  1239.                         case paintSameRgn:
  1240.                             key integer = $0089;
  1241.  
  1242.                         case eraseSameRgn:
  1243.                             key integer = $008A;
  1244.  
  1245.                         case invertSameRgn:
  1246.                             key integer = $008B;
  1247.  
  1248.                         case fillSameRgn:
  1249.                             key integer = $008C;
  1250.  
  1251.                         case AppleReserved008D:
  1252.                             key integer = $008D;
  1253.  
  1254.                         case AppleReserved008E:
  1255.                             key integer = $008E;
  1256.  
  1257.                         case AppleReserved008F:
  1258.                             key integer = $008F;
  1259.  
  1260.                         case BitsRect:
  1261.                             key integer = $0090;
  1262.                             unsigned bitstring[1] = 1;                                /* New pixMap flag        */
  1263.                             unsigned bitstring[2] = 0;                                /* Must be 0            */
  1264.     BitsRectpMapRowBytes:    unsigned bitstring[13];                                    /* Offset to next row    */
  1265.     BitsRectBounds2:        rect;                                                    /* Bitmap bounds        */
  1266.                             integer;                                                /* pixMap vers number    */
  1267.                             integer    unpacked;                                        /* Packing format        */
  1268.                             unsigned longint;                                        /* Size of pixel data    */
  1269.                             unsigned hex longint;                                    /* h. resolution (ppi) (fixed) */
  1270.                             unsigned hex longint;                                    /* v. resolution (ppi) (fixed) */
  1271.                             integer            chunky, chunkyPlanar, planar;            /* Pixel storage format    */
  1272.                             integer;                                                /* # bits in pixel        */
  1273.                             integer;                                                /* # components in pixel*/
  1274.                             integer;                                                /* # bits per field        */
  1275.                             unsigned longint;                                        /* Offset to next plane    */
  1276.                             unsigned longint;                                        /* Offset to color table*/
  1277.                             fill long;                                                /* Reserved                */
  1278.                             /* Color Table */
  1279.                             unsigned hex longint;                                    /* ctSeed                */
  1280.                             integer;                                                /* ctFlags                */
  1281.                             integer = $$Countof(ColorSpec) - 1;                        /* ctSize                */
  1282.                             wide array ColorSpec {
  1283.                                     integer;                                        /* value                */
  1284.                                     unsigned integer;                                /* RGB:    red                */
  1285.                                     unsigned integer;                                /*        green            */
  1286.                                     unsigned integer;                                /*        blue            */
  1287.                             };
  1288.                             Rect;                        /* srcRect */
  1289.                             Rect;                        /* destRect */
  1290.                             integer        srcCopy, srcOr, srcXor, srcBic,    /* mode */
  1291.                                         notSrcCopy, notSrcOr, notSrcXor,
  1292.                                         notSrcBic, patCopy, patOr, patXor,
  1293.                                         patBic, notPatCopy, notPatOr, notPatBic,
  1294.                                         blend = 32, addPin, addOver, subPin,
  1295.                                         adMax = 37, subOver, adMin;
  1296.     BitsRectBits:            hex string [$$BitField(BitsRectpMapRowBytes[$$ArrayIndex(OpCodes)],0,13) *
  1297.                                         ($$BitField(BitsRectBounds2[$$ArrayIndex(OpCodes)],32,16)
  1298.                                         - $$BitField(BitsRectBounds2[$$ArrayIndex(OpCodes)],0,16))];
  1299.                         
  1300.                         
  1301.                         case BitsRgn:
  1302.                             key integer = $0091;
  1303.                             unsigned bitstring[1] = 1;                                /* New pixMap flag        */
  1304.                             unsigned bitstring[2] = 0;                                /* Must be 0            */
  1305.     BitsRgnpMapRowBytes:    unsigned bitstring[13];                                    /* Offset to next row    */
  1306.     BitsRgnBounds2:            rect;                                                    /* Bitmap bounds        */
  1307.                             integer;                                                /* pixMap vers number    */
  1308.                             integer    unpacked;                                        /* Packing format        */
  1309.                             unsigned longint;                                        /* Size of pixel data    */
  1310.                             unsigned hex longint;                                    /* h. resolution (ppi) (fixed) */
  1311.                             unsigned hex longint;                                    /* v. resolution (ppi) (fixed) */
  1312.                             integer            chunky, chunkyPlanar, planar;            /* Pixel storage format    */
  1313.                             integer;                                                /* # bits in pixel        */
  1314.                             integer;                                                /* # components in pixel*/
  1315.                             integer;                                                /* # bits per field        */
  1316.                             unsigned longint;                                        /* Offset to next plane    */
  1317.                             unsigned longint;                                        /* Offset to color table*/
  1318.                             fill long;                                                /* Reserved                */
  1319.                             /* Color Table */
  1320.                             unsigned hex longint;                                    /* ctSeed                */
  1321.                             integer;                                                /* ctFlags                */
  1322.                             integer = $$Countof(ColorSpec) - 1;                        /* ctSize                */
  1323.                             wide array ColorSpec {
  1324.                                     integer;                                        /* value                */
  1325.                                     unsigned integer;                                /* RGB:    red                */
  1326.                                     unsigned integer;                                /*        green            */
  1327.                                     unsigned integer;                                /*        blue            */
  1328.                             };
  1329.                             Rect;                        /* srcRect */
  1330.                             Rect;                        /* destRect */
  1331.                             integer        srcCopy, srcOr, srcXor, srcBic,    /* mode */
  1332.                                         notSrcCopy, notSrcOr, notSrcXor,
  1333.                                         notSrcBic, patCopy, patOr, patXor,
  1334.                                         patBic, notPatCopy, notPatOr, notPatBic,
  1335.                                         blend = 32, addPin, addOver, subPin,
  1336.                                         adMax = 37, subOver, adMin;
  1337.     BitsRgnStart2:            integer = (BitsRgnEnd2[$$ArrayIndex(OpCodes)] - BitsRgnStart2[$$ArrayIndex(OpCodes)]) >> 3;
  1338.                             Rect;                /* region's enclosing rect */
  1339.                             hex string [$$Word(BitsRgnStart2[$$ArrayIndex(OpCodes)]) - 10];
  1340.     BitsRgnEnd2:            hex string [$$PackedSize(BitsRgnEnd2[$$ArrayIndex(OpCodes)],
  1341.                                         $$BitField(BitsRgnpMapRowBytes[$$ArrayIndex(OpCodes)],0,13),
  1342.                                         ($$BitField(BitsRgnBounds2[$$ArrayIndex(OpCodes)],32,16)
  1343.                                         - $$BitField(BitsRgnBounds2[$$ArrayIndex(OpCodes)],0,16)))];
  1344.  
  1345.                         case AppleReserved0092:
  1346.                             key integer = $0092;
  1347.     AppleReserved0092Start:    unsigned integer = (AppleReserved0092End[$$ArrayIndex(OpCodes)] - AppleReserved0092Start[$$ArrayIndex(OpCodes)]) >> 3 - 2;
  1348.                             hex string [$$Word(AppleReserved0092Start[$$ArrayIndex(OpCodes)])];
  1349.     AppleReserved0092End:
  1350.                         case AppleReserved0093:
  1351.                             key integer = $0093;
  1352.     AppleReserved0093Start:    unsigned integer = (AppleReserved0093End[$$ArrayIndex(OpCodes)] - AppleReserved0093Start[$$ArrayIndex(OpCodes)]) >> 3 - 2;
  1353.                             hex string [$$Word(AppleReserved0093Start[$$ArrayIndex(OpCodes)])];
  1354.     AppleReserved0093End:
  1355.                         case AppleReserved0094:
  1356.                             key integer = $0094;
  1357.     AppleReserved0094Start:    unsigned integer = (AppleReserved0094End[$$ArrayIndex(OpCodes)] - AppleReserved0094Start[$$ArrayIndex(OpCodes)]) >> 3 - 2;
  1358.                             hex string [$$Word(AppleReserved0094Start[$$ArrayIndex(OpCodes)])];
  1359.     AppleReserved0094End:
  1360.                         case AppleReserved0095:
  1361.                             key integer = $0095;
  1362.     AppleReserved0095Start:    unsigned integer = (AppleReserved0095End[$$ArrayIndex(OpCodes)] - AppleReserved0095Start[$$ArrayIndex(OpCodes)]) >> 3 - 2;
  1363.                             hex string [$$Word(AppleReserved0095Start[$$ArrayIndex(OpCodes)])];
  1364.     AppleReserved0095End:
  1365.                         case AppleReserved0096:
  1366.                             key integer = $0096;
  1367.     AppleReserved0096Start:    unsigned integer = (AppleReserved0096End[$$ArrayIndex(OpCodes)] - AppleReserved0096Start[$$ArrayIndex(OpCodes)]) >> 3 - 2;
  1368.                             hex string [$$Word(AppleReserved0096Start[$$ArrayIndex(OpCodes)])];
  1369.     AppleReserved0096End:
  1370.                         case AppleReserved0097:
  1371.                             key integer = $0097;
  1372.     AppleReserved0097Start:    unsigned integer = (AppleReserved0097End[$$ArrayIndex(OpCodes)] - AppleReserved0097Start[$$ArrayIndex(OpCodes)]) >> 3 - 2;
  1373.                             hex string [$$Word(AppleReserved0097Start[$$ArrayIndex(OpCodes)])];
  1374.     AppleReserved0097End:
  1375.                         case PackBitsRect:
  1376.                             key integer = $0098;
  1377.                             unsigned bitstring[1] = 1;                                /* New pixMap flag        */
  1378.                             unsigned bitstring[2] = 0;                                /* Must be 0            */
  1379.     PackBitsRectpMapRowBytes:unsigned bitstring[13];                                    /* Offset to next row    */
  1380.     PackBitsRectBounds2:    rect;                                                    /* Bitmap bounds        */
  1381.                             integer;                                                /* pixMap vers number    */
  1382.                             integer    unpacked;                                        /* Packing format        */
  1383.                             unsigned longint;                                        /* Size of pixel data    */
  1384.                             unsigned hex longint;                                    /* h. resolution (ppi) (fixed) */
  1385.                             unsigned hex longint;                                    /* v. resolution (ppi) (fixed) */
  1386.                             integer            chunky, chunkyPlanar, planar;            /* Pixel storage format    */
  1387.                             integer;                                                /* # bits in pixel        */
  1388.                             integer;                                                /* # components in pixel*/
  1389.                             integer;                                                /* # bits per field        */
  1390.                             unsigned longint;                                        /* Offset to next plane    */
  1391.                             unsigned longint;                                        /* Offset to color table*/
  1392.                             fill long;                                                /* Reserved                */
  1393.                             /* Color Table */
  1394.                             unsigned hex longint;                                    /* ctSeed                */
  1395.                             integer;                                                /* ctFlags                */
  1396.                             integer = $$Countof(ColorSpec) - 1;                        /* ctSize                */
  1397.                             wide array ColorSpec {
  1398.                                     integer;                                        /* value                */
  1399.                                     unsigned integer;                                /* RGB:    red                */
  1400.                                     unsigned integer;                                /*        green            */
  1401.                                     unsigned integer;                                /*        blue            */
  1402.                             };
  1403.                             Rect;                        /* srcRect */
  1404.                             Rect;                        /* destRect */
  1405.                             integer        srcCopy, srcOr, srcXor, srcBic,    /* mode */
  1406.                                         notSrcCopy, notSrcOr, notSrcXor,
  1407.                                         notSrcBic, patCopy, patOr, patXor,
  1408.                                         patBic, notPatCopy, notPatOr, notPatBic,
  1409.                                         blend = 32, addPin, addOver, subPin,
  1410.                                         adMax = 37, subOver, adMin;
  1411.     PackBitsRectBits:        hex string [$$PackedSize(PackBitsRectBits[$$ArrayIndex(OpCodes)],
  1412.                                         $$BitField(PackBitsRectpMapRowBytes[$$ArrayIndex(OpCodes)],0,13),
  1413.                                         ($$BitField(PackBitsRectBounds2[$$ArrayIndex(OpCodes)],32,16)
  1414.                                         - $$BitField(PackBitsRectBounds2[$$ArrayIndex(OpCodes)],0,16)))];
  1415.                         
  1416.                         case PackBitsRgn:
  1417.                             key integer = $0099;
  1418.                             unsigned bitstring[1] = 1;                                /* New pixMap flag        */
  1419.                             unsigned bitstring[2] = 0;                                /* Must be 0            */
  1420.     PackBitsRgnpMapRowBytes:unsigned bitstring[13];                                    /* Offset to next row    */
  1421.     PackBitsRgnBounds2:    rect;                                                        /* Bitmap bounds        */
  1422.                             integer;                                                /* pixMap vers number    */
  1423.                             integer    unpacked;                                        /* Packing format        */
  1424.                             unsigned longint;                                        /* Size of pixel data    */
  1425.                             unsigned hex longint;                                    /* h. resolution (ppi) (fixed) */
  1426.                             unsigned hex longint;                                    /* v. resolution (ppi) (fixed) */
  1427.                             integer            chunky, chunkyPlanar, planar;            /* Pixel storage format    */
  1428.                             integer;                                                /* # bits in pixel        */
  1429.                             integer;                                                /* # components in pixel*/
  1430.                             integer;                                                /* # bits per field        */
  1431.                             unsigned longint;                                        /* Offset to next plane    */
  1432.                             unsigned longint;                                        /* Offset to color table*/
  1433.                             fill long;                                                /* Reserved                */
  1434.                             /* Color Table */
  1435.                             unsigned hex longint;                                    /* ctSeed                */
  1436.                             integer;                                                /* ctFlags                */
  1437.                             integer = $$Countof(ColorSpec) - 1;                        /* ctSize                */
  1438.                             wide array ColorSpec {
  1439.                                     integer;                                        /* value                */
  1440.                                     unsigned integer;                                /* RGB:    red                */
  1441.                                     unsigned integer;                                /*        green            */
  1442.                                     unsigned integer;                                /*        blue            */
  1443.                             };
  1444.                             Rect;                        /* srcRect */
  1445.                             Rect;                        /* destRect */
  1446.                             integer        srcCopy, srcOr, srcXor, srcBic,    /* mode */
  1447.                                         notSrcCopy, notSrcOr, notSrcXor,
  1448.                                         notSrcBic, patCopy, patOr, patXor,
  1449.                                         patBic, notPatCopy, notPatOr, notPatBic,
  1450.                                         blend = 32, addPin, addOver, subPin,
  1451.                                         adMax = 37, subOver, adMin;
  1452.     packBitsRgnStart2:        integer = (packBitsRgnEnd2[$$ArrayIndex(OpCodes)] - packBitsRgnStart2[$$ArrayIndex(OpCodes)]) >> 3;
  1453.                             Rect;                /* region's enclosing rect */
  1454.                             hex string [$$Word(packBitsRgnStart2[$$ArrayIndex(OpCodes)]) - 10];
  1455.     packBitsRgnEnd2:        hex string [$$PackedSize(packBitsRgnEnd2[$$ArrayIndex(OpCodes)],
  1456.                                         $$BitField(PackBitsRgnpMapRowBytes[$$ArrayIndex(OpCodes)],0,13),
  1457.                                         ($$BitField(PackBitsRgnBounds2[$$ArrayIndex(OpCodes)],32,16)
  1458.                                         - $$BitField(PackBitsRgnBounds2[$$ArrayIndex(OpCodes)],0,16)))];
  1459.  
  1460.                         case AppleReserved009A:
  1461.                             key integer = $009A;
  1462.     AppleReserved009AStart:    unsigned integer = (AppleReserved009AEnd[$$ArrayIndex(OpCodes)] - AppleReserved009AStart[$$ArrayIndex(OpCodes)]) >> 3 - 2;
  1463.                             hex string [$$Word(AppleReserved009AStart[$$ArrayIndex(OpCodes)])];
  1464.     AppleReserved009AEnd:
  1465.                         case AppleReserved009B:
  1466.                             key integer = $009B;
  1467.     AppleReserved009BStart:    unsigned integer = (AppleReserved009BEnd[$$ArrayIndex(OpCodes)] - AppleReserved009BStart[$$ArrayIndex(OpCodes)]) >> 3 - 2;
  1468.                             hex string [$$Word(AppleReserved009BStart[$$ArrayIndex(OpCodes)])];
  1469.     AppleReserved009BEnd:
  1470.                         case AppleReserved009C:
  1471.                             key integer = $009C;
  1472.     AppleReserved009CStart:    unsigned integer = (AppleReserved009CEnd[$$ArrayIndex(OpCodes)] - AppleReserved009CStart[$$ArrayIndex(OpCodes)]) >> 3 - 2;
  1473.                             hex string [$$Word(AppleReserved009CStart[$$ArrayIndex(OpCodes)])];
  1474.     AppleReserved009CEnd:
  1475.                         case AppleReserved009D:
  1476.                             key integer = $009D;
  1477.     AppleReserved009DStart:    unsigned integer = (AppleReserved009DEnd[$$ArrayIndex(OpCodes)] - AppleReserved009DStart[$$ArrayIndex(OpCodes)]) >> 3 - 2;
  1478.                             hex string [$$Word(AppleReserved009DStart[$$ArrayIndex(OpCodes)])];
  1479.     AppleReserved009DEnd:
  1480.                         case AppleReserved009E:
  1481.                             key integer = $009E;
  1482.     AppleReserved009EStart:    unsigned integer = (AppleReserved009EEnd[$$ArrayIndex(OpCodes)] - AppleReserved009EStart[$$ArrayIndex(OpCodes)]) >> 3 - 2;
  1483.                             hex string [$$Word(AppleReserved009EStart[$$ArrayIndex(OpCodes)])];
  1484.     AppleReserved009EEnd:
  1485.                         case AppleReserved009F:
  1486.                             key integer = $009F;
  1487.     AppleReserved009FStart:    unsigned integer = (AppleReserved009FEnd[$$ArrayIndex(OpCodes)] - AppleReserved009FStart[$$ArrayIndex(OpCodes)]) >> 3 - 2;
  1488.                             hex string [$$Word(AppleReserved009FStart[$$ArrayIndex(OpCodes)])];
  1489.     AppleReserved009FEnd:
  1490.                         case ShortComment:
  1491.                             key integer = $00A0;
  1492.                             integer;                            /* comment kind */
  1493.                         
  1494.                         case LongComment:
  1495.                             key integer = $00A1;
  1496.                             integer;                            /* comment kind */
  1497.     longCommentStart2:        integer = (longCommentEnd2[$$ArrayIndex(OpCodes)] - longCommentStart2[$$ArrayIndex(OpCodes)] - 16) >> 3;
  1498.                             hex string [$$Word(longCommentStart2[$$ArrayIndex(OpCodes)])];
  1499.     longCommentEnd2:
  1500.                         case OpEndPic:
  1501.                             key integer = $00FF;
  1502.                         
  1503.                         case HeaderOp:
  1504.                             key integer = $0C00;
  1505.                             longint        Version2 = -1;
  1506.                             /* Fixed point bounding box */
  1507.                             unsigned hex longint;
  1508.                             unsigned hex longint;
  1509.                             unsigned hex longint;
  1510.                             unsigned hex longint;
  1511.                             longint        Version2 = -1;        /* Reserved */
  1512.                         
  1513.                     };
  1514.                     align word;
  1515.                 };
  1516.         };
  1517.     endOfPict:
  1518. };
  1519.  
  1520. #endif __PICT.R__
  1521.